// 版权所有2009 Go作者。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// pem包实现了pem数据编码，该编码源于隐私
// 增强型邮件。如今，PEM编码最常用于TLS密钥和
// 证书。见RFC 1421。
package pem

import (
	"bytes"
	"encoding/base64"
	"errors"
	"io"
	"sort"
	"strings"
)

// 一个块代表一个PEM编码的结构。
// 
// 编码形式为：
// /----开始类型------
// 头
// /base64编码字节
// /----结束类型------
// 其中头可能是键：值行的空序列。
type Block struct {
	Type    string            // 类型，取自序言（即“RSA私钥”）。
	Headers map[string]string // 可选标题。
	Bytes   []byte            // 内容的解码字节。通常是DER编码的ASN。1.结构。
}

// getLine从给定字节
// 数组中\r\n或\n圈定的第一行。该行不包括尾随空格或尾随的新
// 行字节。字节数组的其余部分（也不包括新行
// bytes）也会被返回，这将始终小于原始
// 参数。
func getLine(data []byte) (line, rest []byte) {
	i := bytes.IndexByte(data, '\n')
	var j int
	if i < 0 {
		i = len(data)
		j = i
	} else {
		j = i + 1
		if i > 0 && data[i-1] == '\r' {
			i--
		}
	}
	return bytes.TrimRight(data[0:i], " \t"), data[j:]
}

// removeSpacesAndTabs返回其输入的一个副本，其中包含所有空格和制表符
// removed（如果有）。否则，输入将原封不动地返回。
// 
// base64解码器已经跳过了换行符，所以我们不需要在这里过滤它们。
func removeSpacesAndTabs(data []byte) []byte {
	if !bytes.ContainsAny(data, " \t") {
		// 快速路径；PEM中的大多数base64数据都包含换行符，但
		// 没有空格或制表符。跳过额外的分配，开始工作。
		return data
	}
	result := make([]byte, len(data))
	n := 0

	for _, b := range data {
		if b == ' ' || b == '\t' {
			continue
		}
		result[n] = b
		n++
	}

	return result[0:n]
}

var pemStart = []byte("\n-----BEGIN ")
var pemEnd = []byte("\n-----END ")
var pemEndOfLine = []byte("-----")
var colon = []byte(":")

// 解码将在输入中找到下一个PEM格式的块（证书、私钥
// 等）。它返回该块和输入的其余部分。如果
// 未找到PEM数据，则p为零，整个输入将在
// rest中返回。
func Decode(data []byte) (p *Block, rest []byte) {
	// pemStart以新行开头。然而，在
	// 字节数组的开头，我们将接受不带它的起始字符串。
	rest = data
	for {
		if bytes.HasPrefix(rest, pemStart[1:]) {
			rest = rest[len(pemStart)-1:]
		} else if _, after, ok := bytes.Cut(rest, pemStart); ok {
			rest = after
		} else {
			return nil, data
		}

		var typeLine []byte
		typeLine, rest = getLine(rest)
		if !bytes.HasSuffix(typeLine, pemEndOfLine) {
			continue
		}
		typeLine = typeLine[0 : len(typeLine)-len(pemEndOfLine)]

		p = &Block{
			Headers: make(map[string]string),
			Type:    string(typeLine),
		}

		for {
			// 此循环终止，因为getLine的第二个结果是
			// 始终小于其参数。
			if len(rest) == 0 {
				return nil, data
			}
			line, next := getLine(rest)

			key, val, ok := bytes.Cut(line, colon)
			if !ok {
				break
			}

			// TODO（agl）：需要处理跨行的值。
			key = bytes.TrimSpace(key)
			val = bytes.TrimSpace(val)
			p.Headers[string(key)] = string(val)
			rest = next
		}

		var endIndex, endTrailerIndex int

		// 如果没有标题，结束行可能会立即出现，没有前导换行符。wen jian defg
		if len(p.Headers) == 0 && bytes.HasPrefix(rest, pemEnd[1:]) {
			endIndex = 0
			endTrailerIndex = len(pemEnd) - 1
		} else {
			endIndex = bytes.Index(rest, pemEnd)
			endTrailerIndex = endIndex + len(pemEnd)
		}

		if endIndex < 0 {
			continue
		}

		endTrailer := rest[endTrailerIndex:]
		endTrailerLen := len(typeLine) + len(pemEndOfLine)
		if len(endTrailer) < endTrailerLen {
			continue
		}

		restOfEndLine := endTrailer[endTrailerLen:]
		endTrailer = endTrailer[:endTrailerLen]
		if !bytes.HasPrefix(endTrailer, typeLine) ||
			!bytes.HasSuffix(endTrailer, pemEndOfLine) {
			continue
		}

		// 该行必须仅以空格结尾。
		if s, _ := getLine(restOfEndLine); len(s) != 0 {
			continue
		}

		base64Data := removeSpacesAndTabs(rest[:endIndex])
		p.Bytes = make([]byte, base64.StdEncoding.DecodedLen(len(base64Data)))
		n, err := base64.StdEncoding.Decode(p.Bytes, base64Data)
		if err != nil {
			continue
		}
		p.Bytes = p.Bytes[:n]

		// 1是因为如果PEM块为空，我们可能只匹配了没有
		// 前导换行符的pemEnd。
		_, rest = getLine(rest[endIndex+len(pemEnd)-1:])
		return p, rest
	}
}

const pemLineLength = 64

type lineBreaker struct {
	line [pemLineLength]byte
	used int
	out  io.Writer
}

var nl = []byte{'\n'}

func (l *lineBreaker) Write(b []byte) (n int, err error) {
	if l.used+len(b) < pemLineLength {
		copy(l.line[l.used:], b)
		l.used += len(b)
		return len(b), nil
	}

	n, err = l.out.Write(l.line[0:l.used])
	if err != nil {
		return
	}
	excess := pemLineLength - l.used
	l.used = 0

	n, err = l.out.Write(b[0:excess])
	if err != nil {
		return
	}

	n, err = l.out.Write(nl)
	if err != nil {
		return
	}

	return l.Write(b[excess:])
}

func (l *lineBreaker) Close() (err error) {
	if l.used > 0 {
		_, err = l.out.Write(l.line[0:l.used])
		if err != nil {
			return
		}
		_, err = l.out.Write(nl)
	}

	return
}

func writeHeader(out io.Writer, k, v string) error {
	_, err := out.Write([]byte(k + ": " + v + "\n"))
	return err
}

// Encode将b的PEM编码写入out。
func Encode(out io.Writer, b *Block) error {
	// 在写入任何输出之前检查是否存在无效块。
	for k := range b.Headers {
		if strings.Contains(k, ":") {
			return errors.New("pem: cannot encode a header key that contains a colon")
		}
	}

	// 下面的所有错误都是从底层io转发的。Writer，
	// 所以现在可以安全地写入数据了。

	if _, err := out.Write(pemStart[1:]); err != nil {
		return err
	}
	if _, err := out.Write([]byte(b.Type + "-----\n")); err != nil {
		return err
	}

	if len(b.Headers) > 0 {
		const procType = "Proc-Type"
		h := make([]string, 0, len(b.Headers))
		hasProcType := false
		for k := range b.Headers {
			if k == procType {
				hasProcType = true
				continue
			}
			h = append(h, k)
		}
		// 必须先写入Proc类型头。
		// 请参阅RFC 1421第4.6.1.1节
		if hasProcType {
			if err := writeHeader(out, procType, b.Headers[procType]); err != nil {
				return err
			}
		}
		// 有关输出的一致性，请编写按键排序的其他标题。
		sort.Strings(h)
		for _, k := range h {
			if err := writeHeader(out, k, b.Headers[k]); err != nil {
				return err
			}
		}
		if _, err := out.Write(nl); err != nil {
			return err
		}
	}

	var breaker lineBreaker
	breaker.out = out

	b64 := base64.NewEncoder(base64.StdEncoding, &breaker)
	if _, err := b64.Write(b.Bytes); err != nil {
		return err
	}
	b64.Close()
	breaker.Close()

	if _, err := out.Write(pemEnd[1:]); err != nil {
		return err
	}
	_, err := out.Write([]byte(b.Type + "-----\n"))
	return err
}

// EncodeTomery返回b的PEM编码。
// 
// 如果b的头无效且无法编码，
// EncodeTomery返回零。如果报告有关此错误案例的详细信息很重要，请使用Encode。
func EncodeToMemory(b *Block) []byte {
	var buf bytes.Buffer
	if err := Encode(&buf, b); err != nil {
		return nil
	}
	return buf.Bytes()
}
